The XFaceMaker product line comprises three compatible products with increasingly more powerful capabilities:
XFaceMaker/IDT -- a
powerful Motif
IDT.
XFaceMaker/EL -- an entry-level
UIMS.
XFaceMaker -- the full UIMS,
including the widget class
generation capability.
The following table summarizes the main features of the three products.
o--------------------------------o-----------------o----------------o-------------o | Feature | XFaceMaker/IDT | XFaceMaker/EL | XFaceMaker | O================================O=================O================O=============O | Layout | yes | yes | yes | o--------------------------------+-----------------+----------------+-------------o | FACE interpreter and debugger | no | yes | yes | o--------------------------------+-----------------+----------------+-------------o | Templates | yes | yes | yes | o--------------------------------+-----------------+----------------+-------------o | Xt class generation | no | no | yes | o--------------------------------+-----------------+----------------+-------------o | C++ class generation | no | no | yes | o--------------------------------+-----------------+----------------+-------------o | Active values | nos | yes | yes | o--------------------------------+-----------------+----------------+-------------o | Menu editor | yes | yes | yes | o--------------------------------+-----------------+----------------+-------------o | C code generation | yes | yes | yes | o--------------------------------+-----------------+----------------+-------------o | Import UIL | yes | yes | yes | o--------------------------------+-----------------+----------------+-------------o | Export UIL | yes | yes | yes | o--------------------------------o-----------------o----------------o-------------o
This section surveys the major characteristics of the product line. More details are provided in later sections.
Implementation and support of the
Seeheim model
The XFaceMaker products follow the Seeheim model closely.
GUI layout -- All three products
of the
XFaceMaker product line
support the interactive
layout of the interface. The tools are able to generate C code and a symbolic
description
of the interface designed.
GUI behavior -- The XFaceMaker/EL and
XFaceMaker products support
the specification and interactive testing of interface behavior in the form
of
scripts. Scripts are expressed in FACE, a high-level, C-like programming
language.
In contrast with other products, XFaceMaker/EL and XFaceMaker have a built-in FACE interpreter and debugger allowing the interactive testing and debugging of GUI behavior without leaving the tool.
Advantages of the separation
of
GUI and application as provided by XFaceMaker
XFaceMaker/EL and XFaceMaker provide a clear separation of both GUI layout and GUI behavior from the application proper. We have seen that this has distinct advantages:
The application proper is relieved of
most aspects
of GUI behavior.
Interface layout and behavior
can be
changed within the tool and
independently of the application.
The tool speeds up the GUI design process much
more
than in an IDT.
Active values and
communication
between scripts and application
XFaceMaker/EL and XFaceMaker introduce the active value mechanism, which allows for data communication between variables in the application and variables in GUI behavior scripts. This mechanism is also useful as a signaling mechanism that allows the application to trigger events in the interface and as a mechanism for defining additional resources of Xt or C++ classes generated with the tool.
The active values mechanism is a valuable and original feature of the UIMS products of the XFaceMaker line that considerably simplifies the design of GUI's and applications. The use of active values removes the severe constraints on the programmer imposed by the standard X/Motif application model.
Two modes of operation - Build
mode and Try mode
All three products of the XFaceMaker product line have two major modes of operation - the "Build" mode and the "Try" mode. In Build mode you build the interface and in Try mode you test it. One can switch at any time between these two modes.
Building the interface with XFaceMaker is similar to using a CAD drawing tool. The graphical objects of the Motif toolkit, as well as widgets imported or created with the tool, are represented by icons in "Widget Stores". To lay out the interface you simply click on the desired icon and lay it out the component with the mouse. One can then modify the resources, that is the attributes of any widget by using appropriate dialog boxes. Resources can be extremely diverse - from color or border width to behavior resources.
GUI behavior is just a text resource, the FACE script, that is attached to a widget's callback resource. For example, the Motif button has an "activate callback" resource to which a FACE script can be attached by pointing to it and by entering the text with a text editor. In XFaceMaker, you specify behavior by simply editing the callback resource with the built-in Wx text editor (or your own editor).
When the "build" phase has been completed, you can simply switch to "Try" mode and perform the actions that trigger the corresponding script. The built-in scripting language interpreter executes the script and you can immediately observe the result. A built-in debugger allows you to debug scripts.
Code generated for the GUI
The XFaceMaker products generate several files for the GUI part of the application.
The main output of the GUI part is a description of the GUI in a simple clear-text format called the fm language or format. The fm description of the GUI is easily readable and can be edited directly with a text editor. The fm description contains the list of all the widgets of the interface and of all their resources, including the FACE scripts as text values for callback resources.
In addition to the fm GUI description file, the tools also generate:
C or C++ code for both layout and behavior.
X resource files. These files allow the modification
of all resources of the
application GUI
at run-time.
UIL description files. (UIL is the OSF's GUI
description language.) UIL files
will let other
GUI building tools read interfaces developed with XFaceMaker.
XFaceMaker provides numerous facilities for conveniently managing the GUI. Thus it is possible to store the GUI in several fm files, to define and to manage projects consisting of several fm files.
Interpreted, compiled, and
editable versions of the GUI
There are three ways to build an application with an XFaceMaker-created GUI:
Interpreted GUI. The application's Main
function
uses the fm GUI description
file and
feeds it to a special function of the XFaceMaker library that interprets
the fm
file and constructs the GUI.
Compiled GUI. The XFaceMaker products can also
generate the stand-alone C
code that
will completely construct the GUI in the final application. In this case
the fm
GUI description file is no longer needed.
Editable GUI. XFaceMaker can also generate a
version
of the GUI that is
linked with the
application and with XFaceMaker itself to allow the editing of the GUI while
running the
application. (Only in XFaceMaker/EL and XFaceMaker.)
Using the interpreted GUI mode makes it possible to modify the GUI by simply modifying the fm description file, avoiding the recompilation of the whole application. This method is used quite often because of its flexibility. It is even possible to build an application that will work with several different GUIs. XFaceMaker's own GUI is interpreted from an fm GUI description file, allowing the user to customize XFaceMaker's own interface.
The compiled GUI mode lets you build a stand-alone application in which the GUI is somewhat faster, since the fm file interpretation phase is avoided. In addition, the application does not need the fm GUI description file.
The editable GUI is extremely useful whenever the GUI must be tested or fine-tuned together with the application proper, such as in the case of real-time or mission critical applications.
Object-oriented design through
templates, X Intrinsics and C++ widget classes
The XFaceMaker products provide three variants of reusable objects to enforce an object-oriented design discipline: groups, templates and classes. XFaceMaker is the only tool of the industry to allow the generation of X Intrinsics or C++ classes.
X Intrinsics classes are immediately available within the tool, with no need of any additional linking or loading, for instantiation or the derivation of new classes.
The Dual-Process Architecture
of
XFaceMaker
The XFaceMaker product line uses an innovative dual-process architecture, consisting of two processes cooperating by means of a network communication protocol - XFaceMaker's Main process and the Design process. The Main process manages and displays XFaceMaker's own GUI, while the Design process manages the GUI designed by the user.
This architecture provides numerous advantages:
Automatic fault tolerance. In case of
a design
error, for example an
inconsistent assignment of resources or an error in a script, the Design
process
only will crash and will inform
the Main process of the cause that provoked the crash. The Main process can
than
restart
the Design process in a "trusted" state.
This solves an inherent problem of all GUI builders up to now, in which an
inconsistent
resource assignment led to the crash of the whole tool. In NSL's dual process
architecture
the tool's own interface always stays up and only the Design process, which
is
usually
much smaller than the Main process, must be restarted. Moreover, in the single
process
architecture inconsistent resource errors can only be avoided by numerous
time
consuming tests of inconsistent resource assignments, an impossible task,
given
the huge number
of such cases.
Dynamic Extension. XFaceMaker can be easily
augmented with application
functions or
third party widget classes. It suffices to simply recompile and relink the
Design
process
with these functions or widgets, while the Main process is up. Since the
Design
process is
usually much smaller than the Main process, this operation only takes a few
seconds. This
feature provides XFaceMaker with the flexibility of loading the application
functions in
the tool without exiting it and allows the editing and test of the GUI together
with the rest
of the application.
Embedded full-featured
text editor
The Wx text editor delivered with the XFaceMaker product line is called automatically for editing complex text resource such as FACE scripts, thus providing powerful editing capabilities. The Wx editor is a flexible multiple window, full featured editor that greatly simplifies the editing job. It is also possible to integrate with other popular text editors such as vi or Emacs.
Building the application
The XFaceMaker products generate all the files needed for building the final application, including the main application file, the skeleton for all application functions, the declarations for all application functions and all active values, and the Make file for building the final application. XFaceMaker provides numerous options to help automate the application building process. It provides several options for managing the GUI files of a project, and splitting them across several files.
Comparison of XFaceMaker and
other
GUI builders
This table summarizes the features of XFaceMaker and some of its competitors.
o-------------------------------------------------------o-------------------------------------o-------------------------------o----------------------o------------------------------o | Feature | XFaceMaker | UIM/X | Teleuse | IDTs | | | Non Standard Logics | Visual Edge | Alsys | e.g. BX, | | | | | | X-Designer | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Layout | yes | yes | yes | yes | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Behavior | interpreted & compiled | interpreted & com | compiled | no | | | (FACE) | piled (C) | | | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Behavior test | yes | yes | no | no | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Behavior debugging | yes | no | no | no | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Data sharing between behavior scripts | yes | no | no | no | | and application | | | | | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Groups | yes | yes | yes | yes | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Templates/Style sheets | yes | no | yes | no | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Xt class generation | yes | no | no | no | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | C++ class generation | yes | yes | no | no | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Automatic fault-tolerance | yes | no | no | no | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Dynamic extension with foreign widgets/ | yes | no | no | no | | application libraries and functions | | | | | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Testing of GUI (incl. behavior) and appli | yes (static or dynamic) | yes (only static) | no | no | | cation within the tool | | | | | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Embedded full-featured text editor for | yes | no | no | no | | text resources | | | | | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Embedded project management module | yes | no | no | no | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Application development environment | yes | no | no | no | o-------------------------------------------------------+-------------------------------------+-------------------------------+----------------------+------------------------------o | Seamless integration capabilities in soft | yes | no | no | no | | ware development environment | | | | | o-------------------------------------------------------o-------------------------------------o-------------------------------o----------------------o------------------------------o
